Apparatus and machine-readable medium for generating markup language representing a derived entity which extends or overrides attributes of a base entity

ABSTRACT

A markup language document (e.g. an XML document) may contain a first instance of a markup language element having an attribute with a first, platform-independent value, a second instance of the element having the attribute with a second, platform-specific value, and an indicator that the second value overrides the first. Executable code may replace both of the first and second instances with a single instance having the attribute with the second value. Alternatively the markup language document may contain a first instance of a markup language element having a first, platform-independent attribute, a second instance of the element having a second, platform-specific attribute different from the first attribute, and an indicator that the second instance extends the first. In this case executable code may replace both instances of the markup language element with a single instance having the first attribute and the second attribute.

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by any one of the patent document or patent disclosure, as it appears in a Patent Office patent file or records, but otherwise reserves all copyright rights whatsoever.

FIELD OF THE INVENTION

The present invention relates to markup languages, and more particularly to an apparatus and machine-readable medium for generating markup language representing a derived entity which extends or overrides attributes of a base entity.

BACKGROUND OF THE INVENTION

In the field of computer science, object-oriented design has become a prevalent approach for designing software. Using object-oriented designed methodologies, a designer may implement a base class representing a object, such as an automobile. The designer may assign attributes to the base class representing characteristics of the object which are generally present all instances of the object. In case of an automobile, these characteristics may include an engine and a steering wheel. When a derived class representing a subclass of the object is derived from the base class, the derived class inherits the attributes of the base class, but can also be extended with new attributes. Thus, a “convertible” class derived from the automobile class will inherit the engine and steering wheel attributes, and may extend these with a new roof-retraction mechanism attribute. It may also be possible to override base class attributes in a derived class. For example, if the steering wheel attribute of the base class specifies a location of the steering wheel on the left hand side of the dashboard (North American automobiles), a derived “European sports car” class might override this attribute to specify a location of the steering wheel on the right hand side of the dashboard.

It would be advantageous to be capable of using a markup language, such as extensible markup language (XML), to represent an object-oriented derived class which extends or overrides base class characteristics.

BRIEF DESCRIPTION OF THE DRAWINGS

In the figures which illustrate example embodiments of this invention:

FIG. 1 schematically illustrates a wireless communication device including virtual machine software;

FIG. 2A illustrates the organization of exemplary virtual machine software at the wireless communication device of FIG. 1;

FIG. 2B further illustrates the organization of exemplary virtual machine software at the wireless communication device of FIG. 1;

FIG. 3 illustrates an operating environment for the wireless communication device of FIG. 1;

FIG. 4 illustrates the structure of example application definitions used by the device of FIG. 1;

FIG. 5 schematically illustrates the formation of application definition files at a transaction server of FIG. 3 from a master definition file;

FIG. 6 schematically illustrates the transaction server of FIG. 3 in greater detail;

FIG. 7 is a flow diagram illustrating the exchange of sample messages passed between a wireless communication device, transaction server and application server;

FIGS. 8-10 illustrate operation performed at a wireless communication device under control of virtual machine software of FIGS. 2A and 2B;

FIG. 11 schematically illustrates the wireless communication device operating environment of FIG. 3 with an exemplary Rapid Application Development (RAD) tool which may be used to develop master definition files in a manner exemplary of an embodiment of the present invention;

FIG. 12 schematically illustrates the RAD tool of FIG. 11 in greater detail;

FIG. 13 illustrates an exemplary graphical user interface (GUI) of the RAD tool of FIG. 12;

FIG. 14 illustrates a project explorer portion of the RAD tool GUI of FIG. 13;

FIG. 15 illustrates the common characteristics of a login screen for an exemplary mobile application across multiple platforms;

FIG. 16 illustrates a login screen for a RIM wireless computing device which inherits the characteristics of the login screen of FIG. 15;

FIG. 17 illustrates a login screen for a Pocket PC wireless computing device which inherits the characteristics of the login screen of FIG. 15;

FIGS. 18A-18C textually illustrate a master definition Document Object Model (DOM) tree that is maintained in the memory of the RAD tool of FIG. 12 during mobile application design to represent the screens of FIGS. 15-17; and

FIGS. 19A-19C illustrate a master definition file which results from the serialization of the DOM tree of FIGS. 18A-18C.

DETAILED DESCRIPTION

In one aspect of the below-described embodiment, there is provided an apparatus comprising: at least one processor; and memory coupled to the at least one processor storing: a markup language document containing: a first instance of a markup language element having an attribute with a first, platform-independent value; a second instance of the markup language element having the attribute with a second, platform-specific value, wherein the platform is a platform to which an instance of the markup language element is to be deployed; and an indicator that the second value overrides the first value; and machine-executable code which, when executed by the at least one processor, replaces both of the first instance and the second instance with a single instance of the markup language element having the attribute with the second value.

In another aspect of the below-described embodiment, there is provided an apparatus comprising: at least one processor; and memory coupled to the at least one processor storing; a markup language document containing: a first instance of a markup language element having a first, platform-independent attribute; a second instance of the markup language element having a second, platform-specific attribute different from the first attribute, wherein the platform is a platform to which an instance of the markup language element is to be deployed; and an indicator that the second instance extends the first instance; and machine-executable code which, when executed by the at least one processor, replaces the both of the first instance and the second instance with a single instance of the markup language element having the first attribute and the second attribute.

In yet another aspect of the below-described embodiment, there is provided a machine-readable medium comprising: machine-executable code for replacing, in a markup language document containing: a first instance of a markup language element having an attribute with a first, platform-independent value; a second instance of the markup language element having the attribute with a second, platform-specific value, wherein the platform is a platform to which an instance of the markup language element is to be deployed; and an indicator that the second value overrides the first value, both of the first instance and the second instance with a single instance of the markup language element having the attribute with the second value.

In yet another aspect of the below-described embodiment, there is provided a machine-readable medium comprising: machine-executable code for replacing, in a markup language document containing: a first instance of a markup language element having a first, platform-independent attribute; a second instance of the markup language element having a second, platform-specific attribute different from the first attribute, wherein the platform is a platform to which an instance of the markup language element is to be deployed; and an indicator that the second instance extends the first instance, both of the first instance and the second instance with a single instance of the markup language element having the first attribute and the second attribute.

The embodiment described herein pertains generally to markup languages, and more particularly to an apparatus and machine-readable medium for generating markup language representing a derived entity which extends or overrides attributes of a base entity. The embodiment is described, however, within the specific context of a system that presents server-side applications at varied wireless communication devices (also referred to as “mobile devices”). The exemplary embodiment involves the use of XML to represent a “base class” of common characteristics for a graphical user interface (GUI) screen across multiple wireless computing device types (i.e. across multiple hardware and operating system platforms) as well as multiple “derived classes” defining platform-specific GUI screen characteristics for multiple platforms. The invention should not be understood to be limited to this context.

The system for presenting server-side applications at varied wireless communication devices which serves as the context for the present description was originally described in U.S. Patent Publication No. US 2003/0060896 (which is hereby incorporated by reference hereinto). The latter system is referred to as the “baseline system” for convenience. An overview of the baseline system is initially provided below under the section heading “I. Baseline System Facilitating Execution of Server-Side Applications At Wireless communication devices” to provide a context for the description which follows. Thereafter, a description of a rapid application development (RAD) tool exemplary of an embodiment of the present invention which may be used to facilitate creation of master definition file for use in the baseline system is provided under the section heading “II. Rapid Application Development Tool”.

I. System Facilitating Execution of Server-Side Applications at Wireless Communication Devices

In overview, a system which facilitates execution of server-side applications at wireless communication devices utilizes a text-based application definition file to govern the manner in which an application is presented at a wireless communication device. The application definition file contains a description of how an application is to be presented at wireless communication device, the format of transactions over the wireless network, and a format of data related to the application to be stored at the wireless communication device. The application definition file of the present embodiment written in XML. A virtual machine software component at the wireless communication device interprets the definition file and presents an interface to the application in accordance with the definition file.

FIG. 1 illustrates a wireless communication device 10, exemplary of an embodiment of the present invention. Wireless communication device 10 may be any conventional wireless communication device, modified to function in the manner described below. As such, wireless communication device 10 includes a processor 12, in communication with a network interface 14, storage memory 16, and a user interface 18 typically including a keypad and/or touch-screen. Network interface 14 enables device 10 to transmit and receive data over a wireless network 22. Wireless communication device 10 may be, for example, be a Research in Motion (RIM) two-way paging device, a WinCE based device, a PalmOS device, a WAP enabled mobile telephone, or the like. Memory 16 of device 10 stores a mobile operating system such as the PalmOS, or WinCE operating system software 20. Operating system software 20 typically includes graphical user interface and network interface software having suitable application programmer interfaces (“API”s) for use by other applications executing at device 10.

Memory at device 10 further stores virtual machine software 24 which, when executed by wireless communication device 10, enables device 10 to present an interface for server-side applications provided by a transaction server, described below. Specifically, virtual machine software 24 interprets a textual application definition file (a markup language document) defining a definition of a user interface 18 controlling application functionality, and the display format (including display flow) at device 10 for a particular server-side application; the format of data to be exchanged over the wireless network for the application; and the format of data to be stored locally at device 10 for the application. Virtual machine software 24 uses operating system 20 and associated APIs to interact with device 10, in accordance with the received application definition file. In this way, device 10 may present interfaces for a variety of applications, stored at a server. From the perspective of operating system 20, virtual machine software 24 is viewed as another application resident at device 10. Moreover, multiple wireless devices each having a similar virtual machine software 24 may use a common server-side application in combination with an application definition file, to present a user interface and program flow specifically adapted for the device.

As such, and as will become apparent, the exemplary virtual machine software 24 is specifically adapted to work with the particular wireless communication device 10. Thus if device 10 is a RIM BlackBerry device, virtual machine software 24 is a RIM virtual machine. Similarly, if device 10 is a PalmOS or WinCE device, virtual machine software 24 would be a PalmOS or a WinCE virtual machine. As further illustrated in FIG. 1, virtual machine software 24 is capable of accessing local storage 26 at device 10.

In the present example, the application definition file is formed using the well-known markup language XML. Defined XML entities are understood by the virtual machine software 24. Defined XML entities are detailed in Appendix “A” attached hereto. ARML is an XML markup language used in the present embodiment. The defined XML entities are interpreted by the virtual machine software 24, and may be used as building blocks to present server-side applications at wireless communication device 10, as detailed herein.

Specifically, as illustrated in FIG. 2A, virtual machine software 24 includes a conventional XML parser 61; an event handler 65; a screen generation engine 67; and object classes 69 corresponding to XML entities supported by the virtual machine software 24, and possibly contained within an application definition file 28. Supported XML entities are detailed in Appendix “A”, attached hereto. A person of ordinary skill will readily appreciate that those XML entities identified in Appendix “A” are exemplary only, and may be extended, or shortened as desired.

XML parser 61 may be formed in accordance with the Document Object Model, or DOM, which is available at www.w3.org/DOM/ and is incorporated by reference hereinto. Parser 61 enables virtual machine software 24 to read an application definition file. Using the parser, the virtual machine software 24 may form a binary representation of the application definition file for storage at the wireless communication device, thereby eliminating the need to parse text each time an application is used. Parser 61 may convert each XML tag contained in the application definition file, and its associated data to tokens, for later processing. As will become apparent, this may avoid the need to repeatedly parse the text of an application definition file.

Screen generation engine 67 displays initial and subsequent screens at the wireless communication device, in accordance with an application definition 28, as detailed below.

Event handler 65, of virtual machine software 24 allows device 10 under control of virtual machine software 24 to react to certain external events. Example events include user interaction with presented graphical user interface (GUI) screens or display elements, incoming messages received from a wireless network, or the like.

Object classes 69 also form part of virtual machine 24 and define objects that allow device 10 to process each of the supported XML entities at the wireless communication device. Each of object classes 69 includes attributes (e.g. fields or data members) used to store parameters defined by the XML file (XML element and/or attribute values), and allowing the XML entity to be processed at the wireless communication device, as detailed in Appendix “A”, for each supported XML entity. So, as should be apparent, supported XML entities are extensible. Virtual machine software 24 may be expanded to support XML entities not detailed in Appendix “A”.

As detailed below, upon invocation of a particular application at wireless communication device 10, the virtual machine software 24 presents an initial GUI screen based on the contents of the application definition 28 for the application. GUI screen display elements (e.g. menu items, text items, buttons, etc.) are created by screen generation engine 67 by creating instances of corresponding object classes for defined elements, as contained within object classes 69. The object instances are “customized” using XML element and attribute values contained in the application definition file 28. Thereafter the event handler 65 of the virtual machine software 24 reacts to events for the application. The manner in which the event handler reacts to events is governed by the contents of the application definition file. Events may trigger processing defined within instances of associated “action” objects, which objects are instantiated from object classes 69 of virtual machine software 24.

Similarly, object classes 69 of virtual machine software 24 further include object classes corresponding to data tables and network transactions defined in the Table Definition and Package Definition sections of Appendix “A”. At run time, instances of object classes corresponding to these classes are created and populated with parameters contained within application definition file, as required.

FIG. 2B illustrates in greater detail the manner in which the virtual machine software 24 of FIG. 2A may be organized. For purposes of FIG. 2B it is assumed that the wireless communication device 10 is currently executing a wireless communication device application (also referred to as a “mobile application”). As illustrated, the virtual machine software 24 has two categories of components, namely, objects 169 and general purpose routines 59.

Objects 169 are instantiations of object classes 69 (FIG. 2A) which are instantiated dynamically at run time when the application is executed at the wireless communication device 10. The types of objects 169 that are instantiated at any given moment (e.g. screens, buttons, events, actions, etc., as will be described) depends upon the mobile application currently being executed and its state, including which user interface screen is currently displayed at the wireless communication device. Each of objects 169 corresponds to an application component defined within the application definition file 28. The objects 169 are instantiated from binary representations 178 thereof which are maintained in secondary storage 26, which representations 178 are created when the application definition file 28 is initially parsed. Each object 169 contains methods which capture certain behaviours that are performed by all instances of the represented object, as well as data members which permit the characteristics or behavior of the object to be “customized” (e.g. each instance of a button object may include the same highlight( ) method which, if invoked, causes the button to become highlighted, and may further include X and Y coordinate data member values which define a unique location of the button on the encompassing UI screen). A more detailed description of the exemplary set of objects 169 of FIG. 2B is provided below in conjunction with the description of operation of wireless computing device 10.

General purpose routines 59, on the other hand, constitute a managing environment for the objects 169. The routines 59 encompass functionality which is useful for executing a wireless communication device application at the wireless communication device but is not necessarily tied to a particular type of object 169. For example, the routines 59 may include the XML parser 61, which initially parses the application definition file 28. Other routines may facilitate loading or closing of UI screens, or the sending of messages over the wireless network 22, as will be described. The routines 59 effectively consolidate certain functionality for convenient invocation from any of objects 169, as required.

Using this general description and the description which follows, persons of ordinary skill in the art will be able to form virtual machine software 24 for any particular device. Typically, virtual machine software 24 may be formed using conventional object-oriented programming techniques, and existing device libraries and APIs, as to function as detailed herein. As will be appreciated, the particular format of screen generation engine 67, object classes 69 will vary depending on the type of virtual machine software, its operating system and API available at the device. Once formed, a machine executable version of virtual machine software 24 may be loaded and stored at a wireless communication device, using conventional techniques. It can be embedded in ROM, loaded into RAM over a network, or from a computer readable medium.

Although, in the described embodiment the virtual machine software 24 and software forming object classes 69 are formed using object-oriented structures, persons of ordinary skill will readily appreciate that other approaches could be used to form suitable virtual machine software. For example, object classes 69 forming part of the virtual machine could be replaced by equivalent functions, data structures or subroutines formed using a conventional (i.e. non-object-oriented) programming environment. Operation of virtual machine software 24 under control of an application definition file containing various XML definitions exemplified in Appendix “A” is further detailed below.

FIG. 3 illustrates the operating environment for a wireless communication device 10. Further example wireless communication devices 30, 32 and 34 are also illustrated in FIG. 3. These wireless communication devices 30, 32 and 34 are similar to device 10 and also store and execute virtual machine software.

Virtual machine software like that stored at device 10, executes on each wireless communication device 10, 30, 32, 34, and communicates with a transaction server 44 (referred to as a “middleware server 44” in U.S. Patent Publication No. US 2003/0060896, referenced above) by way of example wireless networks 36 and 38 and network gateways 40 and 42. Example gateways 40 and 42 are generally available as a service for those people wishing to have data access to wireless networks. Wireless networks 36 and 38 are further connected to one or more computer data networks, such as the Internet and/or private data networks by way of gateway 40 or 42. As will be appreciated, embodiments of the invention may work with many types of wireless networks. Transaction server 44 is in turn in communication with a data network, that is in communication with wireless network 36 and 38. The communication used for such communication is via Transmission Control Protocol/Internet Protocol (TCP/IP) over a HyperText Transfer Protocol (HTTP) transport. As could be appreciated, other network protocols such as X.25 or Systems Network Architecture (SNA) could equally be used for this purpose.

At least two categories of communication between transaction server 44 and wireless communication devices 10, 30, 32 and 34 exist. First, virtual machine software 24 at each device may query transaction server 44 for a list of applications that a user of an associated wireless communication device 10, 30, 32 or 34 can make use of. If a user decides to use a particular application, device 10, 30, 32 or 34 can download a text description, in the form of an application definition file, for the application from the transaction server 44 over its wireless interface. Second, virtual machine software 24 may send and receive (as well as present, and locally store) data to and from transaction server 44 which is related to the execution of applications, or its own internal operations. The format of exchanged data for each application is defined by an associated application definition file. Again, the exchanged data may be formatted using XML, in accordance with the application definition file.

Transaction server 44 stores XML application definition files for those applications that have been enabled to work with the various devices 10, 30, 32, and 34 using virtual machine software 24 in a pre-defined format understood by virtual machine software 24. Software providing the functions of the transaction server 44, in the exemplary embodiment is written in C#, using SQL Server or MySQL database.

The XML of the application definition files may conform to XML version 1.0, detailed in the XML version 1.0 specification third edition and available at www.w3.org/TR/2004/REC-xml-20040404, for example.

Each application definition file is formatted according to defined rules and uses pre-determined XML markup tags known by both virtual machine software 24, and complementary transaction server software 68. That is, each application definition file 28 is an XML document (i.e. an XML data instance file) which conforms to a predefined XML schema designed to support the execution of server-side applications at various types of wireless communication devices. Tags define XML elements used as building blocks to present an application at a wireless communication device. Knowledge of these rules, and an understanding of how each tag and section of text should be interpreted, allows virtual machine software 24 to process an XML application definition and thereafter execute an application, as described below. Virtual machine software 24 effectively acts as an interpreter for a given application definition file.

FIG. 4 illustrates an example format for an XML application definition file 28. As illustrated, the example application definition file 28 for a given device and application includes three components: a user interface definition section 48, specific to the user interface for the device 10, which defines the format of graphical user interface (GUI) screen or screens for the application and how the user interacts with them and contains application flow control events and actions; a network transactions definition section 50 defining the format of data to be exchanged with the application; and a local data definition section 52 defining the format of data to be stored locally on the wireless communication device by the application.

Defined XML markup tags are used to create an application definition file 28. The defined tags may broadly be classified into three categories, corresponding to the three sections 48, 50 and 52 of an application definition file 28.

Example XML tags and their corresponding significance are detailed in Appendix “A”. As noted above, virtual machine software 24 at a wireless communication device includes object classes corresponding to each of the XML tags. At run time, instances of the objects are created as required.

Broadly, the following list includes example XML tags (i.e. XML elements) which may be used to define the GUI screens:

-   -   SCREEN—this defines a screen. A SCREEN tag pair contains the         definitions of the user interface elements (buttons, radio         buttons, and the like) and the events associated with the screen         and its elements     -   BTN—this tag defines a button and its associated attributes     -   LB—this tag defines a list box that allows selection of an item         from a list of items     -   CHOICE—this tag defines a choice item, that allows selection of         an item from a set of items     -   MENU—the application developer will use this tag to define a         menu for a given screen     -   MENUITEM—defines a selectable item on a given menu     -   EB—this tag defines an edit box for entering textual content     -   TI—this tag describes a text label that is displayed     -   CHK—this tag describes a checkbox     -   GRID—this tag defines a grid made up of a configurable number of         columns and rows defining cells for containing textual content     -   EVENT—this defines an event to be processed by the virtual         machine software. Events can be defined against the application         as a whole, individual screens or individual items on a given         screen. Sample events would be receipt of data over the wireless         interface, or an edit of text in an edit box by a wireless         communication device user.     -   ACTION—this describes a particular action should be performed         upon the occurrence of a particular event. Sample actions would         be navigating to a new window or displaying a message box.

The second category of example XML tags describes the network transaction section 50 of application definition 28. These may include the following example XML tags:

-   -   TUPDATE—using this tag, the application developer can define an         update that is performed to a table in the device's local         storage. Attributes allow the update to be performed against         multiple rows in a given table at once.

PKGFIELD—this tag is used to define a field in a data package (message) that passes over the wireless interface

The third category of XML tags used to describe an application are those used to define a logical database that may be stored at the wireless communication device. The tags available that may be used in this section are:

-   -   TDEF—this tag, and its attributes and subordinate field tags,         define a table. Contained within a pair of TDEF tags are         definitions of the fields contained in that table. The         attributes of a table control such standard relational database         functions as the primary key for the table.     -   FLD—this tag describes a field and its attributes. Attributes of         a field are those found in a standard relational database         system, such as the data type, whether the field relates to one         in a different table, the need to index the field, and so on.

In addition to these XML tags, virtual machine software 24 may, from time to time, need to perform certain administrative functions on behalf of a user. In order to do this, one of object classes 69 has its own repertoire of tags to intercommunicate with the transaction server 44. Such tags differ from the previous three groupings in that they do not form part of an application definition file, but are solely used for administrative communications between the virtual machine software 24 and the transaction server 44. Data packages using these tags are composed and sent due to user interactions with the virtual machine's configuration screens. The tags used for this include:

-   -   REG—this allows the application to register and deregister a         user for use with the transaction server     -   FINDAPPS—by using this operation, users can interrogate the         server for the list of applications that are available to them     -   APPREG—using this operation, the end-user can register (or         deregister) for an application and have the application         interface downloaded automatically to their device (or remove         the interface description from the device's local storage).     -   SA—If the user's preferred device is malfunctioning, or out of         power or coverage, they will need a mechanism to tell the Server         to attempt delivery to a different device. The Set Active (SA)         command allows the user to set the device that they are         currently using as their active one

Referring again generally to the manner in which execution of server-based applications at wireless communication devices is facilitated, FIG. 5 illustrates the organization of application definitions at transaction server 44 and how transaction server 44 may form an application definition file 28 (FIG. 4) for a given device 10, 30, 32 or 34. In the illustration of FIG. 5, only two wireless communication devices 10 and 30 are considered. Typically, since network transactions and local data are the same across devices, the only piece of the application definition that varies for different devices is the user interface definition (i.e. the definition of its GUI screens).

So, transaction server 44 stores a master definition file 58 (or simply “master definition” 58) for a given server-side application. This master definition 58 contains example user interface descriptions 48, 54, 56 for each possible type of wireless communication device 10, 30, 32; descriptions of the network transactions 50 that are possible and data descriptions 52 of the data to be stored locally on the wireless communication device. Typically the network transactions 50 and data descriptions 52 will be the same for all wireless communication devices 10, 30 and 32, while the user interface descriptions 48, 54, and 56 vary slightly from one another. This may for example be due to display size limitations on some wireless communication devices which force a designer to lay out the display elements of a user interface slightly differently from device to device.

For device 10, transaction server 44 composes an application definition file 28 by querying the device type and adding an appropriate user interface description 48 for device 10 to the definitions for the network transactions 50 and the data 52. For device 30, transaction server 44 composes the application definition file 28 by adding the user interface description 54 for device 30 to the definitions for the network transactions 50 and data 52. These two files 28 may be thought of as platform-specific versions of a mobile application. The files 28 are deployed to devices 10 and 30, which have distinct platforms, for interpretation at run time by virtual machine software 24 at each device. The term “platform” generally refers to the underlying hardware or software technology of a computing device which allows software to be executed (e.g. hardware architecture or operating system). Thus, the set of markup language elements that is deployed to the device 10 may be different than the set of markup language elements deployed to the device 30.

The master definition 58 for a given application is created away from the transaction server 44 and may be loaded onto the transaction server 44 by administrative staff charged with its operation. Master definition files may be created by a developer using a rapid application development tool such the one that is described below in Section II. Alternatively, a simple text editor could be used. It will be appreciated that the master definition file 58 is an XML document.

FIG. 6 illustrates the organization of transaction server 44. Transaction server 44 may be any conventional application server, modified to function in as described herein. As such, transaction server 44 includes a processor 60, in communication with a network interface 66 and storage memory 64. Transaction server 44 may be, for example, a server running Windows Server 2003, a Sun Solaris server, or the 8 like. Memory of transaction server 44 stores an operating system such as Windows Server 2003, or Solaris operating system software 62.

Network interface 66 enables transaction server 44 to transmit and receive data over a data network 63. Transmissions are used to communicate with both the virtual machine software 24 (via the wireless networks 36, 38 and wireless gateways 40, 42 of FIG. 3) and one or more application servers, such as application server 70, that are the end recipients of data sent from the mobile client applications and the generators of data that is sent to the mobile client applications.

Memory at transaction server 44 further stores software 68 which, when executed by transaction server 44, enables the transaction server to understand and compose XML data packages that are sent and received by the transaction server 44. These packages may be exchanged between transaction server 44 and the virtual machine software 24, or between the transaction server 44 and the application server 70. Transaction server software 68 may be loaded from a machine-readable medium.

As described above, communication between the application server 70 and the transaction server 44 can, in an exemplary embodiment, use HTTP running on top of a standard TCP/IP stack; however this is not a requirement. An HTTP connection between a running application at the application server 70 and the transaction server 44 is established in response to the application at a wireless communication device presenting the application. The server-side application provides output to transaction server 44 over this connection. The server-side application data is formatted into appropriate XML data packages understood by the virtual machine software 24 at a wireless communication device by the server-side application.

That is, a server-side application (or an interface portion of the application) formats application output into XML in a manner consistent with the format defined by the application definition file for the application. Alternatively, an interface component separate from the application could easily be formed with an understanding of the format and output for a particular application. That is, with a knowledge of the format of data provided and expected by an application at application server 70, an interface component could be a produced using techniques readily understood by those of ordinary skill. The interface portion could translate application output to XML, as expected by transaction server 44. Similarly, the interface portion may translate XML input from a wireless communication device into a format understood by the server-side application.

The particular identity of the wireless communication device on which the application is to be presented may be identified by a suitable identifier, in the form of a header contained in the server-side application output. This header may be used by transaction server 44 to forward the data to the appropriate wireless communication device. Alternatively, the identity of the connection could be used to forward the data to the appropriate wireless communication device.

FIG. 7 illustrates a sequence diagram detailing data (application data or application definition files 28) flow between wireless communication device 10 and transaction server 44.

For data requested from transaction server 44, device 10, executing virtual machine software 24, makes a request to transaction server 44, which passes over the wireless network 36 through network gateway 40. Network gateway 40 passes the request to the transaction server 44. Transaction server 44 responds by executing a database query on its database 46 that finds which applications are available to the user and the user's wireless communication device. For data passed from transaction server 44 to device 10, data is routed through network gateway 40. Network gateway 40 forwards the information to the user's wireless communication device over the wireless network 36.

FIG. 7 when considered with FIG. 3 illustrates a sequence of communications between virtual machine software 24 (executing at device 10) and transaction server 44 that may occur when the user of a wireless communication device wishes to download an application definition file 28 for a server-side application.

Initially device 10 may interrogate server 44 to determine which applications are available for the particular wireless communication device being used. This may be accomplished by the user instructing the virtual machine software 24 at device 10 to interrogate the server 44. Responsive to these instructions the virtual machine software 24 sends an XML message to the server requesting the list of applications (data flow 72); the XML message may contain the <FINDAPPS> tag, signifying to the transaction server 44, its desire for a list available application. In response, transaction server 44 makes a query to database 46. Database 46, responsive to this query, returns a list of applications that are available to the user and the wireless communication device. The list is typically based, at least in part, on the type of wireless communication device making the request, and the applications known to transaction server 44. Transaction server 44 converts this list to an XML message and sends to the virtual machine (data flow 74). Again, a suitable XML tag identifies the message as containing the list of available applications.

In response, a user at device 10 may choose to register for an available server-side application. When a user chooses to register for an application, virtual machine software 24 at device 10 composes and sends an XML registration request for a selected application (data flow 76) to transaction server 44. As illustrated in FIG. 7, an XML message containing a <REG> tag is sent to transaction server 44. The name of the application is specified in the message. The transaction server 44, in response, queries its database for the user interface definition for the selected application for the user's wireless communication device. Thereafter, the transaction server creates the application definition file, as detailed with reference to FIG. 5. Then, transaction server 44 sends to the wireless communication device (data flow 78—FIG. 7) the created application definition file 28.

The user is then able to use the functionality defined by the interface description to send and receive data.

At this time, parser 61 of virtual machine software 24 may parse the XML text of the application definition file to form a tokenized version of the file. That is, each XML tag may be converted a defined token for compact storage, and to minimize repeated parsing of the XML text file. The tokenized version of the application definition file may be stored for immediate or later use by device 10. In this context, the term “tokenized” may refer to placement of the XML structure into binary objects which are run-time accessible, which is much like conversion of a script into byte code.

The application definition file may initially be converted to a DOM tree representation. The entire DOM tree may then be traversed. For each XML element that is encountered during the traversal, a corresponding object 169 (FIG. 2B) may be instantiated from one of object classes 69. Instantiation of each object 169 may be facilitated by a fromXML( ) “constructor” method within the corresponding class 69, which populates the object's data members based on XML element/attribute values. For example, the constructor method may receive the XML fragment which defines the XML element in the application definition file 28 and, based on element and attribute values within the fragment, automatically populate the newly instantiated object's data members with like values. It is noted that the constructor method may or may not meet the strict definition the term “constructor” as it is understood in the context of certain object-oriented programming languages (e.g. the method may not have the same name as the class).

For purposes of illustrating the instantiation of a subset of the objects 169 of FIG. 2B, it is assumed that the following XML fragment is read from an application definition file 28:

<BTN NAME=”BTN1” INDEX=”1” CAPTION=”OK”>   <EVENTS>     <EVENT TYPE=”ONCLICK” ...>       <ACTION ...>       <ACTION ...>     </EVENT>   </EVENTS>

The above XML fragment represents an “OK” button on a containing GUI screen (not shown) which performs two actions when clicked. The details of the actions are omitted for brevity. When a DOM tree representation of the above is encountered, the result may be instantiation of the button object 173 (FIG. 2B) from the following one of classes 69:

Public class button { str name; int index; str caption; event[ ] events;  // event array fromXML(<XML>) { ... } // “constructor” writeToPersistantStorage( ) { ... } readFromPersistantStorage( ) { ... } onEvent( ) { ... } : }

The data members “name”, “index” and “caption” of object 173 correspond to attributes of the same name within the XML fragment. The constructor method fromXML( ) populates these data members with the values “BTN1”, “1” and “OK”, respectively, based on the relevant XML attribute values.

The constructor method also populates the event array of button object 173. The event array is an array of event objects, each representing a different type of event that is significant with regard to the containing GUI screen display element (in this case, button object 173). In the above example, only one significant event is defined for the “OK” button, namely, an “ONCLICK” event which represents the clicking of the button. Accordingly, only one event object 175 is instantiated. The event object's data members includes an array of action objects 177 and 179 (one for each action element in the above XML fragment) representing actions to be taken when the event occurs. Each action object is also populated by a constructor method within the action object, in like fashion.

The result of instantiating the button object and subordinate objects is illustrated in FIG. 2B. The button object is shown at 173, within the context of objects 169. In FIG. 2B, illustration of an object within the border of another object connotes the latter object's containment of the former. In the present embodiment a contained object is a data member of the containing object.

The button object 173 is contained within a screen object 171 which also includes an edit box object 181. This hierarchy indicates a UI screen having both a button and an edit box. The sole significant event for the button object 173 is represented by event object 175, which is the sole member of the event array of button object 173. The event object 175 in turn contain action objects 177 and 179 which represent actions that are to be taken when the containing event occurs. The actions may be of various types, as will be described.

The remaining objects 169 of FIG. 2B are based on other portions of the application definition file 28 which are not expressly set forth above. Briefly, the edit box object 181 of FIG. 2B contains two events 183 and 191, each representing a significant event for the edit box (say, selection and text entry). These event objects in turn contain actions 185, 193 and 195, representing actions to be taken when the relevant event occurs.

The button class contains an onEvent( ) method. This method is invoked via a callback from the operating system 20 upon the detection of any event pertaining to the button UI construct for purposes of determining whether the detected event is significant and thus requires action to be taken. Other UI constructs, such as edit boxes, menu items, and the like also have a similar method. Cumulatively, these methods within instantiated objects 169 may comprise event handler 65 of FIG. 2A.

Each class also includes a writeToPersistentStorage( ) method which saves the object's state by storing data member values, e.g. to a file system. The values are typically stored in a binary representation. This method is invoked during initial DOM tree traversal for purposes of writing newly instantiated objects which are not immediately needed to persistent storage. Once the data has been so stored, the objects may be de-allocated, and as a result, it is not necessary to maintain a vast set of objects representative of the entire application definition file 28 within wireless communication device memory. Only objects 169 pertaining to the current wireless communication device application state are instantiated at any given time, and wireless communication device resources are thereby conserved. A corresponding readFromPersistentStorage( ) method permits a newly instantiated object to restore its previous state from persistent storage, e.g., when a screen is loaded due to user navigation to that screen. By initially storing the entire set of objects to persistent storage in this fashion, the need to maintain a DOM tree is avoided.

Thereafter, upon invocation of a particular application for which the device 10 has registered, the screen generation engine 67 of the virtual machine software 24 at the device causes the virtual device to locate the definition of an initial screen for that application. The initially loaded screen will be the one identified within the application definition file 28 for that application by way of the attribute <First screen=“yes”>.

Operation for loading a first or subsequent screen is illustrated in FIG. 8. To load a screen, generation engine 67 may employ a loadScreen(X) routine, which may be one of the general purpose routines 59 within virtual machine software 24 (FIG. 2B). This routine may accept as a parameter a unique screen identifier X. Based on that identifier, the routine may find the appropriate representation of the named screen within local storage 26 (as previously stored by the writeToPersistentStorage( ) method of that screen when the DOM tree was initially traversed), instantiate a new screen object 169 (S802), and cause the new screen object to populate itself with the stored data, e.g. through invocation of the readFromPersistentStorage( ) method of the screen object. The latter method may in turn instantiate subordinate objects (such as buttons, edit boxes, menus, list boxes, choice items, images and checkboxes, as detailed in Appendix “A”) and cause the readFromPersistentStorage( ) methods of these subordinate objects to be called, in an iterative fashion. In the result, a hierarchy of instances 169 of object classes 69 are created within the virtual machine software 24, as illustrated in FIG. 2B.

Each definition of a visual UI construct (also referred to as a “display element”) causes virtual machine software 24 to use the operating system of the wireless communication device to create corresponding display element of a graphical user interface as more particularly illustrated in FIG. 8. Specifically, for each element (S804, S814, S824, S834 and S844), the associated XML definition is read in (S806, S816, S826, S836 and S846) and a corresponding instance of a screen object defined as part of the virtual machine software 24 is created by the virtual machine software 24 (at S808, S818, S828, S838 and S848), in accordance with S902 and onward illustrated in FIG. 9. Each interface object instance is created at S902. Each instance takes as attribute values defined by the XML text associated with the element. A method of the virtual machine object is further called (S904), and causes a corresponding device operating system object to be created (S906). Attributes originally defined in the XML text file, as stored within the virtual machine object instance, are applied to the corresponding instance of a display object created using the device operating system (S908-S914). This is repeated for all attributes of the virtual machine object instance. For any element allowing user interaction, giving rise to an operating system event, the event handler 65 of virtual machine software 24 is registered to process operating system events. This may for example entail registering, for each UI construct on the screen (e.g. buttons, menu items, etc.), a callback to an onEvent( ) method of the UI construct, which will be invoked upon the occurrence of any event in respect of that construct for purposes of determining whether the event is significant, such that the event's actions should be executed as a result. The onEvent( ) methods for all of the objects which are associated with the currently displayed screen may constitute the event handler 65 for that screen. That is, there may be no distinct instance of an event handler 65 per se other than the onEvent( ) methods of currently displayed or instantiated UI construct objects.

As described above and illustrated in FIG. 2B, for each event (as identified by an <EVENT> tag in the application definition file 28) and action (as identified by an <ACTION> tag), virtual machine software 24 creates an instance of a corresponding event and action object forming part of virtual machine software 24. Virtual machine software 24 maintains a list identifying each instance of each event and action object, which may take the form of arrays of event objects and subordinate arrays of action objects as described above (S916 to S928).

Operation at S902-S930 is repeated for each element of the screen at S808, S818, S828, S838 and S848 as illustrated in FIG. 8. All elements originally defined between the <SCREEN> definition tags of the application definition file are so processed. After the entire screen has been so created in memory, it is displayed (S854), using conventional techniques.

Events may be handled by virtual machine software 24 as illustrated in FIG. 10. Operation at S1002 and onward is performed in response to the operating system detecting an event.

Upon the occurrence of an event, such as the receipt of data from a wireless network 36 or 38 or user interaction with user interface controls at the wireless communication device, the operating system automatically invokes the onEvent( ) method for each object 169 in respect of which callback was earlier registered (S1002). The onEvent( ) method for these objects determines whether the event is significant for the object (S1004) and, if so (S1006), passes control to each of the action(s) in the array of action objects within the relevant event object, in succession (S1008-S1016), for purposes of effecting the desired behaviour. Control may for example be passed by invoking a doAction( ) method of each instance of an action object within the action object array that comprises the data members of the relevant event object, in order to effect desired processing as defined by the XML <ACTION> tag. The result of executing this method may be loading a named screen, closing the current screen, sending a message, storage data locally at the device, or other actions, as described below. Within the doAction( ) method of each action object, hard-coded instructions which cause these action to be performed. For actions having associated element or attribute values within the action object's data members which affect the action's characteristics or behavior, the result of executing the instructions may be influenced by these values, which effectively serve as parameters to the action.

In some cases, instructions within the doAction( ) method may invoke a general purpose routine. For example, if an action specifies that a screen should be closed, a “destroy screen X” routine 181, which is one of general purpose routines 59 (FIG. 2B) in the present embodiment, may be invoked from the action object's doAction( ) method. This routine may traverse screen objects within the instantiated objects 169 until the screen with the specified name X is found, at which point that screen object may be instructed to destroy itself. If the action indicates that a message (package) should be sent, a “createXMLPackage( )” general purpose routine 187 (FIG. 2B) may be invoked from the action object's doAction( ) method, to create and send a message over wireless network 22 containing specified data. According to that routine 187, methods within an XML builder object may assemble data into an XML package which is then passed to message server object. The message server object may use the device's network APIs to transmit the assembled XML package across the wireless network.

By executing actions which cause new screens to be loaded or closed, navigation through the screens of the application is accomplished according to the definition embodied in the application definition file 28.

If the event is the receipt of an XML package from the wireless network 22, then the relevant event objects will not be directly contained within a UI construct object within objects 169 (as shown in FIG. 2B). Rather, the relevant event objects will be defined at the application level or at the screen level, depending upon whether the data event is defined as an application-level event (i.e. significant regardless of the currently displayed screen) or a screen-level event (i.e. only significant when a particular screen is displayed), respectively. When an XML package is received, the event objects whose onEvent( ) methods are invoked will be at the same level as, or will be directly contained by, the screen object corresponding to the currently displayed screen (FIG. 2B).

So, for example, as illustrated in FIG. 7, a user could send a login request 80 by interacting with an initial login screen, defined in the application definition file for the application. This would be passed by the transaction server 44 to the backend application server 70. The backend application server according to the logic embedded within its application, would return a login response 82, which the transaction server 44 would pass to the virtual machine software 24. Other applications, running on the same or other application servers might involve different interactions, the nature of such interactions being based upon the functionality and logic embedded within the application server 70.

II. Rapid Application Development Tool

In order to facilitate the development of a master definition file 58 (and, indirectly, application definition files 28) for use in the system described above, a rapid application development tool may be used. An exemplary RAD tool 116 (or simply “tool 116”) is illustrated in FIG. 11. FIG. 11 illustrates the tool 116 within the wireless communication device operating environment of FIG. 3. Wireless communication device 30 of FIG. 3 is omitted from FIG. 11 for clarity.

The RAD tool 116 of FIG. 11 is a computing device 118, such as an Intel®-Processor based personal computer (PC) for example, executing rapid application development (RAD) software, which may be loaded from a machine-readable medium such as an optical disk 120. The tool 116 allows the developer to create a master application definition file 58 from which device-specific application definition files 28 may be generated. Completed master definition files 58 are uploaded from computing device 118 to transaction server 44, via network 119, which may be an Ethernet local area network for example, for downloading to wireless communication devices 10, 32 and 34. In turn, the device-specific application definition file 28, when downloaded, interpreted and executed at a wireless communication device 10, 32 or 34, permits the wireless communication device to emulate and intercommunicate with an application that is actually executing on an application server 70 (FIG. 6), as described above.

FIG. 12 illustrates RAD tool 116 in greater detail. In the present embodiment the tool 116 is a PC 118 executing RAD software 130. The PC 118 includes a processor 134 in communication with memory 132 which stores the software 130. The PC 118 further includes a conventional display 138, such as a Cathode Ray Tube (CRT) monitor or flat-screen display for example, and a conventional user input mechanism (UIM) 145, such as a keyboard and/or mouse for example. The PC 118 also includes a network interface card 142 (e.g. an Ethernet interface) which facilitates communication by the tool 116 over network 119 (FIG. 11), e.g. for purposes of uploading a completed master definition file 58 from secondary storage 146 to the transaction server 44.

In overview, when RAD software 130 is executed by PC 118, it provides an intuitive graphical user interface which facilitates “drag and drop” application development, so that even developers who lack depth of expertise in software development may “develop a mobile application” (i.e. may generate a master definition file 58). The procedure for developing a mobile application essentially consists of creating a visual hierarchy or “tree” of icons which correlates to a logical hierarchy of XML markup elements (e.g. as defined in Appendix “A”). The created visual hierarchy may be similar to a graphical directory and file structure representation in a conventional graphical operating system. Each icon represents a building block of the application (e.g. a GUI screen, a database table for storing program data, action to be executed upon the occurrence of a defined event etc.) and corresponds to a defined XML element with attributes. As a user creates icons and assigns properties to them, the tool 116 automatically generates a dynamically-accessible representation of the corresponding hierarchy of XML elements and attributes within memory 132, in the form of a master definition DOM tree 150 data structure. A DOM tree is essentially a dynamically accessible representation of an XML document that is well understood in the art. Within this master definition DOM tree 150, a technique is employed to efficiently represent multiple instances of a GUI screen having some display elements in common. This technique is a focus of the present description, and is detailed below. When the user of tool 116 has completed development of the mobile application, the application is “published”, i.e. the master definition DOM tree 150 is serialized to form a master definition file 58, using a mechanism exemplary of the present invention.

The RAD software 130, which may be referred to by the proprietary name “AIRIX Design Studio” or simply “Design Studio”, may be implemented as a set of plug-ins to a generic integrated design environment (IDE) framework such as the Eclipse framework. As is known in the art, the Eclipse platform is designed for building integrated development environments that can be used to create various applications such as web sites, embedded Java™ programs, C++ programs, and Enterprise JavaBeans™ for example. The platform exposes mechanisms to use and rules to follow to tool providers via well-defined APIs, classes and methods. The RAD software 130 may be written in Delphi, using an SQL Server database for example.

FIG. 13 illustrates an exemplary GUI 1300 of the RAD tool 116 when the RAD software 130 is executed. The GUI 1300 includes various components, including a toolbar 1302, a project explorer 1304, and a main design area 1306.

Toolbar 1302 includes a menu list and icons for performing various development activities during mobile application development. Activities which may be performed include opening a new project, compiling a current mobile application, and publishing a current mobile application. The term “project” refers to the mobile application under development. Compiling refers to the checking of various aspects of an application for errors or deviations from good programming practices. Compilation may cause hints, warnings or errors to be displayed, e.g.:

-   -   Hint—screen “AddScrn” for device “RIM” has an IF action and has         no actions for its ELSE LIST.     -   Warning—Value “[SP.screenname. savename]” is used in the action         “gotomm” on screen “AddScrn” for device “RIM”. It should be         noted that if this scratchpad (a temporary buffer on the         wireless communication device capable of storing variables under         a name “savename” on a screen-specific basis) or query value         results to null, the OPEN command will not open a screen.     -   Error—The action “NewAction” on MenuItem “addloc” on screen         “AddScrn” for device “RIM” cannot have a blank screen.

Publishing refers to the creation of a master definition file 58 by serializing the master definition DOM tree 150. Publishing may cause hints, warnings or errors to be displayed, as during compilation.

The project explorer 1304 contains the visual hierarchy of icons 1305 that is created by the developer to represent the mobile application. In FIG. 13, the visual hierarchy 1305 defines a simple inventory application for a Pocket PC mobile device. A more detailed view of the project explorer 1304 is provided in FIG. 14, which is described below.

Main design area 1306 of FIG. 13 displays the currently-selected application component of project explorer 1304. When an icon is selected in the visual hierarchy 1305, a graphical representation of the relevant component (e.g. a screen or database table) and its properties appears in main design area 1306. For example, in FIG. 13 icon 1308 representing a Pocket PC GUI screen has been selected, as indicated by reverse video. As a result, an “interface designer” GUI that is specific to the relevant platform appears in design area 1306. The Pocket PC interface designer GUI includes a number of GUI areas, namely, a screen designer 1310, an interface component drop down list 1312 and a properties tab 1314.

The screen designer 1310 is a “screen painter” window which displays a graphical representation of the relevant wireless communication device type (a “virtual device”) for which screens are to be created. The designer 1310 permits a developer to design screens by dragging and dropping display elements (such as buttons, edit boxes, or other widgets.) to the virtual device screen in the window, offering a “what you see is what you get” (WYSIWYG) view of the interface screen under development.

The interface component drop down list 1312 facilitates definition and selection of individual GUI display elements which make up the screen as displayed within the interface designer window 1310.

The properties tab 1314 displays the properties of the interface component that is currently selected in the drop down list 1312. Properties that are generally applicable to the overall screen may also be displayed. Displayed properties may be updated as desired.

FIG. 14 illustrates project explorer 1304 in greater detail. In FIG. 14, a different visual hieararchy 1400, “Project—Example”, than that which is shown in FIG. 13 is illustrated. For simplicity, the project defines only one GUI screen (a login screen), as will be described.

The visual hierarchy 1400 includes platform-independent components 1402 and platform-specific components 1404. Platform-independent components 1402 are application components (building blocks) which are present in each platform's version of a mobile application. Put another way, the application definition file 28 which will ultimately represent that mobile application will contain components 1402, in XML form, regardless of platform. Platform-specific components 1404, on the other hand, may vary from platform to platform. Typically, it is the GUI screens of a wireless communication device application which will differ in some measure between platforms, due to differences in the capabilities of the devices (e.g. screen size and supported display elements).

As shown in FIG. 14, the platform-independent components 1402, which comprises the Device Independent branch of the visual hierarchy, include application events 1406, data rules 1408, database tables 1410 and base screens 1412.

Application events 1406 are definitions of occurrences which trigger processing within the mobile application regardless of the application's status (e.g. regardless of which GUI screen is presently displayed). For example, the receipt of an XML package at the wireless communication device can be defined as an application level event. It is noted that a developer may also define screen level events (arrival of an XML package when a specific screen is displayed) and control level events (user manipulation of a GUI control such as a button press), however these are defined separately from application level events 1406. Screen level events and control-level events may be defined either under the base GUI screens section 1412 (if multiple instances of a GUI screen share a common event definition) or in the platform-specific components 1404 section (if an event is platform specific), as will be described. It is further noted that at least one action is normally defined in conjunction with each event to define the processing that will occur upon the occurrence of the associated event.

Data rules 1408 dictate how XML packages received from enterprise applications affect data stored in database tables associated with an application. A rule typically defines which field(s) of a table will be impacted by incoming data and the nature of the impact. Because rules make reference to database tables, logically they are defined after the tables (described below) have been defined. Like application-level events 1406, data rules 1408 are wireless computing device type-independent. Rules also dictate how to apply changes to database tables from XML created in an outgoing XML transaction in the context of an ARML action.

Database tables 1410 are defined by a developer for purposes of storing data at run time for use by the mobile application executing at the wireless communication device.

Base screens section 1412 contains definitions of display elements for GUI screens which appear in all versions (all platforms) of a mobile application. Typically, the base screens section 1412 will include a screen definition for each GUI screen in a mobile application (although this is not a requirement). This is because mobile application developers often make an effort to design each version of a screen to look essentially the same regardless of wireless computing device platform (to the extent possible given platform-specific limitations), thus many display elements will be the same for each platform version of a screen. For each screen that is defined in the base screen section 1412, only the display elements of the screen that are common to each platform are defined.

The base screens section 1412 of FIG. 14 contains only one screen definition 1414 which corresponds to the sole GUI screen (a login screen) of the exemplary mobile application. When the base login screen definition 1414 is created, the screen's properties, such as the name by which it will be known in RAD tool 116 (“BaseLoginScr”) and the title (“Login”) which will appear when the screen is displayed (assuming no overriding title at the platform level), are defined in the properties area (1314, FIG. 13) of the RAD tool GUI, as illustrated in inset 1450 of FIG. 14. If the present mobile application were to include other screens, additional base screen definitions could be added to base screens section 1412.

Four display element icons A, B, C and D appear below screen definition 1414 in hierarchy 1400 (FIG. 14). These icons represent display elements which are common to all platform's versions of the login screen. Display elements A and B are text items while display elements C and D are edit boxes. When text item A is defined, its properties, such as the name by which is will be known internally in RAD tool 116, its index number (order of appearance), the caption (i.e. textual content) that will be displayed when the screen is displayed, and the X and Y coordinates of the text on the login screen, are defined by the developer in the properties area (1314, FIG. 13) of the RAD tool GUI, as illustrated at inset 1452 of FIG. 14.

In combination, screen definition 1414 and display element definitions A, B, C and D in FIG. 14 effectively define a base screen 1500 as shown in FIG. 15. It will be appreciated that screen 1500 is a notional screen, since GUI screens defined in the base screens section 1412 should be referenced in the platform-specific components section 1404, as described below, in order to be displayable.

Referring back to FIG. 14, platform-specific components section 1404, which comprises the Operating Systems branch of the visual hierarchy 1400, is where displayable GUI screens are defined. For each screen definition created in platform-specific components section 1404, the screen properties will include not only a name and a title, but also an optional base screen. When a base screen is specified, it is understood that the platform-specific screen will take on the characteristics of the base screen in the absence of overriding characteristics at the platform level. Section 1404 contains two branches, namely, a RIM branch 1416 and a Pocket PC branch 1420.

RIM-specific screen definitions are defined within RIM branch 1416. In the present embodiment, only one screen (a RIM-specific instance of the login screen) is defined for the RIM platform. This screen is represented by screen definition 1420. The properties of screen definition 1420 are shown at inset 1454. As illustrated, a base screen named “BaseLoginscr” has been selected in drop down list 1456. This indicates that the screen definition 1420 and its subordinate display elements E and F define enhancements to the base login screen defined in platform-independent screen definition 1414. The drop down list 1456 enumerates each of the screens defined under the base screens icon 1412. The overriding of a characteristic of the base screen—in this case the overriding of the title “Login” with “RIM Login”—is illustrated at 1458.

Below the RIM login screen definition 1420, additional RIM-specific login screen display elements E and F representing a Login menu item and Cancel menu item, respectively, are defined. At run time, the Login menu item is intended to be selected by the wireless computing device user after a username and password have been entered in the appropriate edit boxes 1 and 2, in order to trigger the login process, while the Cancel menu item may alternatively be selected to abort the login operation. Display elements E and F are defined at the RIM platform level because it is not desired for the menu items to exist in the login screen for any other platform (since other GUI controls, namely buttons, will be used for the login screen of the only other platform, Pocket PC, as described below).

The RIM login screen which results from screen definition 1420 and the definition of display elements E and F is illustrated in FIG. 16 at 1600. As can be seen in FIG. 16, display elements A, B, C and D as defined in the base screen, are present in the RIM screen, having been “inherited” from the base screen (the different appearance of edit boxes C and D in FIGS. 15 and 16 being attributable solely to differences in the platforms' representation of edit boxes). Moreover, the screen 1600 further includes RIM screen-specific display elements E and F. The title of the screen 1600, “RIM Login”, is the overriding title as set at the RIM platform level (1458, FIG. 14).

Referring back to FIG. 14, Pocket PC-specific screen definitions are defined in Pocket PC branch 1418. A single screen definition 1422 in that branch defines enhancements to the base login screen defined in device-independent screen definition 1414. The base login screen 1414 is specified as the base screen for the Pocket PC login screen in the latter screen's properties (not illustrated). Below the screen definition 1422, additional Pocket PC-specific display elements G, H and I are defined. Display elements G and H represent a Login button and a Cancel button, which are intended to serve a purpose analogous to the menu item elements E and F of the RIM screen 1600 (FIG. 16). Display element I, on the other hand, defines overriding characteristics for edit box D. In particular, the properties for display element I (not expressly illustrated) define new X and Y coordinates for the edit box. This illustrates the fact that platform-independent characteristics can be overridden by platform-specific characteristics (specifically, a platform-specific attribute value can override a platform-independent attribute value). The icon for display element I may be modified with an indicator (e.g. an asterisk, as shown in FIG. 14) to indicate the fact that display element I specifies characteristics that override the characteristics of a base display element (display element D).

In addition to defining overriding X and Y coordinates, the properties for display element I also define platform-specific characteristics for edit box D in the Pocket PC (WinCE) platform by specifying an additional, platform-specific attribute, i.e. the HT attribute (FIG. 18C, line 85), which is absent from the EB element defining the base screen edit box (the latter element containing only platform-independent attributes).

The Pocket PC login screen which results from screen definition 1422 and display elements G, H and I is illustrated in FIG. 17 at 1700. The fact that the password edit box 1702 takes some of its properties from the base display element definition D and some properties (X and Y co-ordinates and HT) from Pocket PC display element definition I is reflected by the reference characters “D+I” near edit box 1702.

It is noted that the present embodiment does not permit a display element defined within a base GUI screen to be deleted outright at the platform level. It may however be possible to change the properties of a base screen's display element for a particular platform to make it appear as though the display element does not exist in that platform's version of the screen (e.g. by overriding a “visible” characteristic at the platform level to make the display element invisible or by setting X and Y coordinates to “off-screen” coordinate values).

Referring to FIGS. 18A-18C, the master definition DOM tree 150 of FIG. 12 is illustrated in greater detail. DOM tree 150 is represented textually as XML in FIGS. 18A-18C for ease of reference. It will be appreciated that the DOM tree 150 in memory 132 of RAD tool 116 (FIG. 12) is actually a dynamically-accessible representation. The DOM tree 150 of FIGS. 18A-18C corresponds to the developer's mobile application design illustrated in the project explorer 1304 of FIG. 14 (i.e., the DOM tree 150 is automatically generated in memory 132 by RAD tool 116 as a result of the developer's creation of the “Project—Example” application as shown in FIG. 14).

Two relevant portions of the master definition DOM tree 150 are illustrated in FIGS. 18A-18C. The first portion 1800 (lines 3-20 of FIG. 18A) corresponds to the base screens section 1412 of FIG. 14 and includes the definition of base login screen 1414. The second portion 1802 (lines 26-90 of FIGS. 18A-18C) corresponds to the platform-specific components section 1404 of FIG. 14. Other portions of the master definition DOM tree 150 are omitted for brevity.

Portion 1800 includes the XML elements and attributes corresponding to all of the common display elements as defined in base screen section 1402 of FIG. 14. In the present embodiment this includes display elements A, B, C and D under base login screen definition 1414. The properties defined for each display are represented as XML attributes of the corresponding XML element of DOM tree 150. For example, in the case of text item 1, which is represented at lines 8-9 of FIG. 18A, the corresponding XML element TI defines five XML attributes—NAME, INDEX, CAPTION, X and Y—whose values are taken from the properties specified at inset 1452 of FIG. 14. In portion 1800, the SCREEN element constitutes a root XML element for the subtree of XML elements defined at lines 5-19 which represent the common characteristics of the login GUI screen.

Portion 1802, on the other hand, includes the XML elements and attributes corresponding to all of the display elements defined in platform-specific components section 1404 of FIG. 14. The XML elements and attributes corresponding to display elements E and F defined for the RIM-specific login screen under RIM branch 1416 of FIG. 14 appear at lines 29-55 of FIG. 18A-18B. The subtree of XML elements defined at lines 29-55 represents a particular instance of the login GUI screen for the RIM platform. The fact that the RIM screen definition at line 29 of FIG. 18A is to inherit the properties (characteristics) of the base login screen is indicated by the attribute BASE=“BASELOGINSCR”, which identifies the platform-independent screen having name “BASELOGINSCR” as the base screen from which the screen definition at line 29 is to be derived. That is, the BASE attribute of the SCREEN element, which is the root XML element of the XML element subtree at lines 29-55, uniquely identifies the root SCREEN element of the XML element subtree defined at lines 5-19. Drawing an analogy to object-oriented design, the XML element SCREEN at lines 29-55 of FIGS. 18A-18B is the derived object.

The Pocket PC screen definition commencing at line 60 of FIG. 18C similarly identifies the device-independent screen having name “BASELOGINSCR” as its base screen. The XML elements and attributes corresponding to display elements G, H and I defined under Pocket PC branch 1418 of FIG. 14 appear at lines 60-87 of FIG. 18C.

It is noted that each of elements E, F, G and H has an associated event and action defined in the relevant portion of DOM tree 150 (e.g., for element E, the associated event is defined at lines 34-43 of FIG. 18B; the subordinate action specified at lines 35-42 causes a login message, which is presumed to be defined elsewhere within master definition DOM tree 150, to be sent to application server 70 of FIG. 6 when the corresponding menu item is selected). These events are understood to have been defined in conjunction with the relevant display elements in project explorer 1304, although the event definitions are omitted from FIG. 14 for brevity. It is further noted that the XML element EB which represents overriding and extended characteristics for display element I (edit box 2) only includes XML attributes for the overriding characteristics (i.e. new X and Y coordinates) and the additional characteristic (HT attribute). Any XML attributes that are not specified at the platform-specific level are assumed to have the values of the associated base screen display element D.

FIGS. 19A-19C illustrate the master definition file 58 (an XML document) that is generated through serialization of the master definition DOM tree 150 of FIGS. 18A-18C. Only the portion of the master definition file 58 which defines the GUI screens for the RIM and Pocket PC platforms is illustrated in FIGS. 19A-19C. More specifically, the RIM-specific screens of the mobile application (which in this embodiment includes only the login screen) defined at lines 3-46 of FIGS. 19A and 19B, and the Pocket PC-specific screens are defined at lines 47-88 of FIGS. 19B and 19C.

Referring first to FIGS. 19A and 19B, it can be seen that the RIM login screen definition at lines 5-44 represents a “merging” of the characteristics of the base login screen defined at lines 5-19 of the master definition DOM tree 150 (FIG. 18A) and the RIM-specific display elements defined at lines 29-55 of DOM tree 150 (FIGS. 18A and 18B). Essentially, the RIM login screen definition in master definition file 58 reproduces all of XML elements and attributes defined for the base login screen in DOM tree 150 (e.g. the XML that represents display elements A, B, C and D) except that: (a) any XML attributes for which new values are specified in the RIM specific portion of DOM tree 150 (e.g. the “RIM Login” title attribute at line 5 of FIG. 19A) are overridden with the new values; and (b) any RIM-specific XML elements and attributes defined in the RIM specific portion of DOM tree 150 (e.g. the XML representing display elements E and F) are added.

Similarly, the Pocket PC login screen definition at lines 49-86 of FIGS. 19B-19C represents a “merging” of the base login screen defined at lines 5-19 of the master definition DOM tree 150 (FIG. 18A) and the Pocket PC-specific display elements defined at lines 60-87 of DOM tree 150 (FIGS. 18B and 18C). Base screen display elements A, B, C and D are represented at lines 75-78 and 81-84 of FIG. 19C, although, because the X and Y coordinate attribute values for display element D at line 84 of FIG. 19C are the overriding X and Y coordinate attribute values for display element I taken from line 85 of FIG. 18C, and because the HT attribute is a platform-specific attribute that is also taken from line 85, editbox2 is labelled as display element “D+I” in FIG. 19C. Pocket PC-specific XML elements and attributes representing Pocket PC-specific buttons G and H appear at lines 51-73 of FIGS. 19B and 19C.

As should now be appreciated, the exercise of determining which display elements of a GUI screen should be defined in the platform-independent components section 1402 of project explorer 1304 and which display elements of the GUI screen should be defined in the platform-specific components section 1404 is analogous to the exercise of defining a base class and one or more derived classes in an object-oriented programming language. Display elements which are common to all platform versions of a screen are declared in a screen definition in the platform-independent components section, and are understood to apply to all versions of the screen. This is similar to defining base class attributes or methods. Platform-specific display elements or overriding characteristics of platform-independent display elements, on the other hand, are defined in platform-specific screen definitions in the platform-specific components section, and are understood to apply only to the relevant platform's screen version. This is similar to defining derived class attributes or methods. The described approach for defining “base” and “derived” objects using markup language builds upon these concepts.

Of course, it will be appreciated this approach described herein is not necessarily limited to GUI screens, but rather may be applied to virtually any type of entity capable of being represented by markup language elements and attributes. for which multiple instances sharing some common characteristics may be declared.

As described above, an indicator of the fact that one XML element (such as a SCREEN element) is derived from another “base” XML element (e.g. another SCREEN element), may take the form of a BASE (or similar) attribute specified in the derived XML element having a value matching a unique value of a NAME (or similar) attribute of the base XML element. Alternatively, or in conjunction, XML elements defined in a first subtree of XML elements may be understood by their membership in the first subtree to be “base class” XML elements, while an XML element defined in a second subtree of XML elements having the same name as one of the XML elements of the first subtree may be understood to constitute a “derived” XML element defining additional or overriding characteristics to the identically named base-class XML element. In the latter case, membership of the XML elements in the first and second subtrees serves as the indicator that the “derived” XML elements extend or override the “base” XML elements. An attribute of a root XML element of the second hierarchy may have a value that serves to identify the first subtree by uniquely identifying a root XML element of the first subtree.

In the above-described embodiment, the master definition file 58 of FIGS. 19A-19C is generated by machine-readable code comprising the RAD software 130 which traverses and serializes the DOM tree 150 using the above-described technique. This traversal and serialization are performed upon user selection of a “publish” command of RAD tool 116. However, the master definition file 58 could alternatively be generated by machine-executable parser code which parses a textual version of the master definition DOM tree 150 (as shown in FIGS. 18A-18C for example), or through other techniques.

Use of the term “markup language document” or “XML document” herein is understood to include not only textual (e.g. ASCII) electronic files, but other document representations, such as DOM trees or Simple API for XML (SAX) representations for example.

As will be appreciated by those skilled in the art, modifications to the above-described embodiment can be made without departing from the essence of the invention. For example, another markup language such as Standard Generalized Markup Language could be employed instead of XML.

Other modifications will be apparent to those skilled in the art and, therefore, the invention is defined in the claims. 

1. An apparatus comprising: at least one processor; and memory coupled to said at least one processor storing: a markup language document containing: a first instance of a markup language element having an attribute with a first, platform-independent value; a second instance of said markup language element having said attribute with a second, platform-specific value, wherein said platform is a platform to which an instance of said markup language element is to be deployed; and an indicator that said second value overrides said first value; and machine-executable code which, when executed by the at least one processor, replaces both of said first instance and said second instance with a single instance of said markup language element having said attribute with said second value.
 2. The apparatus of claim 1 wherein said markup language element represents a graphical user interface (GUI) screen display element and wherein said attribute represents a characteristic of said GUI screen display element.
 3. The apparatus of claim 1, wherein said indicator comprises a membership of said first instance of said markup language element in a first subtree of said markup language document and a membership of said second instance of said markup language element in a second subtree of said markup language document.
 4. The apparatus of claim 3, wherein said first subtree of said markup language document has a first root element, said second subtree of said markup language document has a second root element, and an attribute of said second root element has a value uniquely identifying said first root element.
 5. The apparatus of claim 1 wherein said indicator comprises an attribute in said second instance of said markup language element uniquely identifying said first instance of said markup language element.
 6. The apparatus of claim 1 wherein said markup language is extensible markup language (XML), said markup language document is at least one XML document, said markup language element is an XML element, and said attribute is an XML attribute.
 7. The apparatus of claim 1 wherein said platform is a wireless communication device platform.
 8. An apparatus comprising: at least one processor; and memory coupled to said at least one processor storing; a markup language document containing: a first instance of a markup language element having a first, platform-independent attribute; a second instance of said markup language element having a second, platform-specific attribute different from said first attribute, wherein said platform is a platform to which an instance of said markup language element is to be deployed; and an indicator that said second instance extends said first instance; and machine-executable code which, when executed by the at least one processor, replaces said both of said first instance and said second instance with a single instance of said markup language element having said first attribute and said second attribute.
 9. The apparatus of claim 8 wherein said markup language element represents a graphical user interface (GUI) screen display element and wherein said first and second attributes represent characteristics of said GUI screen display element.
 10. The apparatus of claim 8, wherein said indicator comprises a membership of said first instance of said markup language element in a first subtree of said markup language document and a membership of said second instance of said markup language element in a second subtree of said markup language document.
 11. The apparatus of claim 10, wherein said first subtree of said markup language document has a first root element, said second subtree of said markup language document has a second root element, and an attribute of said second root element has a value uniquely identifying said first root element.
 12. The apparatus of claim 8 wherein said indicator comprises an attribute in said second instance of said markup language element uniquely identifying said first instance of said markup language element.
 13. The apparatus of claim 8 wherein said markup language is extensible markup language (XML), said markup language document is at least one XML document, said markup language element is an XML element, and said attribute is an XML attribute.
 14. The apparatus of claim 8 wherein said platform is a wireless communication device platform.
 15. A machine-readable medium comprising: machine-executable code for replacing, in a markup language document containing: a first instance of a markup language element having an attribute with a first, platform-independent value; a second instance of said markup language element having said attribute with a second, platform-specific value, wherein said platform is a platform to which an instance of said markup language element is to be deployed; and an indicator that said second value overrides said first value, both of said first instance and said second instance with a single instance of said markup language element having said attribute with said second value.
 16. The machine-readable medium of claim 15 wherein said markup language element represents a graphical user interface (GUI) screen display element and wherein said attribute represents a characteristic of said GUI screen display element.
 17. The machine-readable medium of claim 15, wherein said indicator comprises a membership of said first instance of said markup language element in a first subtree of said markup language document and a membership of said second instance of said markup language element in a second subtree of said markup language document.
 18. The machine-readable medium of claim 17, wherein said first subtree of said markup language document has a first root element, said second subtree of said markup language document has a second root element, and an attribute of said second root element has a value uniquely identifying said first root element.
 19. The machine-readable medium of claim 15 wherein said indicator comprises an attribute in said second instance of said markup language element uniquely identifying said first instance of said markup language element.
 20. The machine-readable medium of claim 15 wherein said markup language is Extensible Markup Language (XML), said markup language document is at least one XML document, said markup language element is an XML element, and said attribute is an XML attribute.
 21. The machine-readable medium of claim 15 wherein said platform is a wireless communication device platform.
 22. A machine-readable medium comprising: machine-executable code for replacing, in a markup language document containing: a first instance of a markup language element having a first, platform-independent attribute; a second instance of said markup language element having a second, platform-specific attribute different from said first attribute, wherein said platform is a platform to which an instance of said markup language element is to be deployed; and an indicator that said second instance extends said first instance, both of said first instance and said second instance with a single instance of said markup language element having said first attribute and said second attribute.
 23. The machine-readable medium of claim 22 wherein said markup language element represents a graphical user interface (GUI) screen display element and wherein said attribute represents a characteristic of said GUI screen display element.
 24. The machine-readable medium of claim 22, wherein said indicator comprises a membership of said first instance of said markup language element in a first subtree of said markup language document and a membership of said second instance of said markup language element in a second subtree of said markup language document.
 25. The machine-readable medium of claim 24, wherein said first subtree of said markup language document has a first root element, said second subtree of said markup language document has a second root element, and an attribute of said second root element has a value uniquely identifying said first root element.
 26. The machine-readable medium of claim 22 wherein said indicator comprises an attribute in said second instance of said markup language element uniquely identifying said first instance of said markup language element.
 27. The machine-readable medium of claim 22 wherein said markup language is extensible markup language (XML), said markup language document is at least one XML document, said markup language element is an XML element, and said attribute is an XML attribute.
 28. The machine-readable medium of claim 22 wherein said platform is a wireless communication device platform. 